#include "pfileitem.h"

#include "QtDebug.h"

string PFileItem::m_objname = "PFileItem";

PFileItem::PFileItem():
        m_moduleType ( EXA_MODULE_OBJ_UNKNOWN ),
    m_moduleFileName ( "" ),
           m_current ( false )
{

}

PFileItem::PFileItem(ExaModuleObj module, string file_name, bool current, const PRef &ref):
             m_moduleType ( module ),
         m_moduleFileName ( file_name ),
                m_current ( current ),
                    PRef(ref)
{

}

PFileItem::PFileItem(const PKeyList* plist, int index) :
    PItem(plist->getListId()),
    m_index_of_moduleList(index)
{

}

PFileItem& PFileItem::operator = (const PFileItem& item)
{
        m_moduleType = item.m_moduleType;
    m_moduleFileName = item.m_moduleFileName;
           m_current = item.m_current;

    // Per la parte di [PKey]
    setKeyStr(item.getKeyStr());
     setDescr( item.getDescr());

    // Per la parte di [PItem]
    if ( item.getTabRef() != EXA_TAB_NULL )
    {
        setTabRef(item.getTabRef());
    }

    // Per la classe [PRef]
    PRef::operator = ( item );

    return *this;
}

ExaModuleObj PFileItem::getModuleType ( void ) const
{
    return m_moduleType;
}

string PFileItem::getModuleFileName ( void ) const
{
    return m_moduleFileName;
}

bool PFileItem::isModuleCurrent ( void ) const
{
    return m_current;
}

ExaModuleObj PFileItem::moduleObj( int i )
{
    switch (i)
    {
    case  -1: return EXA_MODULE_OBJ_UNKNOWN;
    case   0: return EXA_MODULE_OBJ_DAT_CAPISALDI;
    case   1: return EXA_MODULE_OBJ_OUT_SPECTRUM;
    case   2: return EXA_MODULE_OBJ_DAT_SEC_CONCRETE;
    case   3: return EXA_MODULE_OBJ_OUT_SEC_CONCRETE;
    case   4: return EXA_MODULE_OBJ_DAT_SEC_STEEL;
    case   5: return EXA_MODULE_OBJ_OUT_SEC_STEEL;
    case   6: return EXA_MODULE_OBJ_DAT_SEC_TIMBER;
    case   7: return EXA_MODULE_OBJ_OUT_SEC_TIMBER;
    default : return EXA_MODULE_OBJ_UNKNOWN;
    }
}

string PFileItem::moduleObjName( ExaModuleObj m )
{
    switch (m)
    {
    case EXA_MODULE_OBJ_UNKNOWN:          return "[...]";
    case EXA_MODULE_OBJ_DAT_CAPISALDI:    return "[DATSPECTRUM]";
    case EXA_MODULE_OBJ_OUT_SPECTRUM:     return "[OUTSPECTRUM]";
    case EXA_MODULE_OBJ_DAT_SEC_CONCRETE: return "[DATCONCRETE]";
    case EXA_MODULE_OBJ_OUT_SEC_CONCRETE: return "[OUTCONCRETE]";
    case EXA_MODULE_OBJ_DAT_SEC_STEEL:    return "[DATSTEEL]";
    case EXA_MODULE_OBJ_OUT_SEC_STEEL:    return "[OUTSTEEL]";
    case EXA_MODULE_OBJ_DAT_SEC_TIMBER:   return "[DATTIMBER]";
    case EXA_MODULE_OBJ_OUT_SEC_TIMBER:   return "[OUTTIMBER]";
    default :                             return "[...]";
    }
}

bool PFileItem::moduleIsExclusive ( ExaModuleObj m )
{
    switch (m)
    {
    case EXA_MODULE_OBJ_UNKNOWN:          return true;
    case EXA_MODULE_OBJ_DAT_CAPISALDI:    return true;
    case EXA_MODULE_OBJ_OUT_SPECTRUM:     return true;
    case EXA_MODULE_OBJ_DAT_SEC_CONCRETE: return true;
    case EXA_MODULE_OBJ_OUT_SEC_CONCRETE: return false;
    case EXA_MODULE_OBJ_DAT_SEC_STEEL:    return true;
    case EXA_MODULE_OBJ_OUT_SEC_STEEL:    return true;
    case EXA_MODULE_OBJ_DAT_SEC_TIMBER:   return true;
    case EXA_MODULE_OBJ_OUT_SEC_TIMBER:   return true;
    default :                             return true;
    }
}

list<ExaModuleObj> PFileItem::moduleRefsFrom ( ExaModuleObj m )
{
    list<ExaModuleObj> list_of_modules;
    switch (m)
    {
    case EXA_MODULE_OBJ_UNKNOWN: break;
    case EXA_MODULE_OBJ_DAT_CAPISALDI: break;
    case EXA_MODULE_OBJ_OUT_SPECTRUM:
    {
        list_of_modules.push_back(EXA_MODULE_OBJ_DAT_CAPISALDI);
    }
    case EXA_MODULE_OBJ_DAT_SEC_CONCRETE: break;
    case EXA_MODULE_OBJ_OUT_SEC_CONCRETE: break;
    case EXA_MODULE_OBJ_DAT_SEC_STEEL: break;
    case EXA_MODULE_OBJ_OUT_SEC_STEEL: break;
    case EXA_MODULE_OBJ_DAT_SEC_TIMBER: break;
    case EXA_MODULE_OBJ_OUT_SEC_TIMBER: break;
    default :
        return list_of_modules;
    }
    return list_of_modules;
}

list<string> PFileItem::moduleListName (void)
{
    int i=0;
    list<string> l;
    ExaModuleObj m = moduleObj(i);
    while ( m != EXA_MODULE_OBJ_UNKNOWN )
    {
        l.push_back(moduleObjName(m));
        i=i+1;
        m = PFileItem::moduleObj(i);
    }
    return l;
}

ExaModuleErr PFileItem::setModuleCurrent ( bool b )
{
    ExaFileErr err;
    if (m_current != b)
    {

        // Cerco di ottenere il gestore
        AbstractModule* mod;
        mod = AbstractModule::getModule(m_moduleType);
        if (!mod)
        {
            return EXA_MODULE_ERR_NOTINSTALLED;
        }

        // Se ottengo il gestore rendo corrente il modulo
        m_current = b;

        if (b)
        {
            // Se ottengo il gestore cancello i dati precedenti
            mod->resetModule();

            if (existFile())
            {
                // Il file esiste e lo apro
                err = mod->fileOpen(m_moduleFileName);
                qDebug()<<"set corrente: il file esiste e lo apro err="<<err;
            }
            else
            {
                // Il file non esiste e lo creo
                err = mod->fileSave(m_moduleFileName);

                // Resetto da un dato di default
//                mod->resetModule();

                qDebug()<<"set corrente: il file non esiste e lo creo err="<<err;

            }
        }
        else
        {
            err = mod->fileSave(m_moduleFileName);

            // Se ottengo il gestore cancello i dati precedenti
            mod->resetModule();

            qDebug()<<"set non corrente: il file lo salvo err="<<err;
        }
        if (err != EXA_FILE_ERR_OK)
        {
            switch (err)
            {
            case EXA_FILE_ERR_UNKNOWN:    return EXA_MODULE_FILE_ERR_UNKNOWN;
            case EXA_FILE_ERR_RECENT:     return EXA_MODULE_FILE_ERR_RECENT;
            case EXA_FILE_ERR_READONLY:   return EXA_MODULE_FILE_ERR_READONLY;
            case EXA_FILE_ERR_WRITEONLY:  return EXA_MODULE_FILE_ERR_WRITEONLY;
            case EXA_FILE_ERR_GENERIC:    return EXA_MODULE_FILE_ERR_GENERIC;
            case EXA_FILE_ERR_MN_UNKNOWN: return EXA_MODULE_FILE_ERR_MN_UNKNOWN;
            case EXA_FILE_ERR_MN_OBJ:     return EXA_MODULE_FILE_ERR_MN_OBJ;
            case EXA_FILE_ERR_MN_FORMAT:  return EXA_MODULE_FILE_ERR_MN_FORMAT;
            case EXA_FILE_ERR_MN_VERSION: return EXA_MODULE_FILE_ERR_MN_VERSION;
            default :                     return EXA_MODULE_FILE_ERR_UNKNOWN;
            }
        }
        // TODO: potrebbe non essere necessario
        mod->setIndexOfModuleList(m_index_of_moduleList);
    }
    return EXA_MODULE_ERR_OK;
}

void PFileItem::setModuleFileName ( string file_name )
{
    m_moduleFileName = file_name;
}

bool PFileItem::removeModuleFile ( void )
{
    QFile f;
    f.setFileName(QSTR(m_moduleFileName));
    return f.remove();
}

void PFileItem::setModuleType ( ExaModuleObj m )
{
    m_moduleType = m;
}

void PFileItem::reportMake(const string& objname) const
{
    if (getReportCurrentStyle() == STYLE_VERBOSE)
    {
        PReport::resetReportOpt();
        PReport::setReportOpt("SUB",true);
        PKeyItem::reportMake();
        PReport::setReportOpt("SUB",false);
        moveLineInBlock(string("VALORI"));
        addInLine("tipo",PFileItem::moduleObjName(m_moduleType),16);
        addInLine("file",m_moduleFileName,16);
        addInLine("corrente",m_current);
        moveLineInBlock();
    }
    else if (getReportCurrentStyle() == STYLE_COMPACT)
    {
        addInLine("ID",getKeyStr(),2);
        addInLine("des.",getDescr());
        addInLine("TAB",getTabRef(),2);
        addInLine("tipo",PFileItem::moduleObjName(m_moduleType));
        addInLine("file",m_moduleFileName);
        addInLine("corrente",m_current);
        moveLineInBlock();
    }
    PReport::reportMake(m_objname);
}

bool PFileItem::existFile ( void ) const
{
    string file_name = getModuleFileName();
    return QFile::exists(QSTR(file_name));
}

int PFileItem::getIndexOfModuleList ( void ) const
{
    return m_index_of_moduleList;
}

void PFileItem::setIndexOfModuleList ( int i )
{
    m_index_of_moduleList = i;
}

void PFileItem::buildRefs (const vector<PKeyItem> &vec)
{
    appendRefFrom(vec);
}
